package com.zjc615.util;

import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
import org.springframework.beans.PropertyAccessorFactory;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.util.*;

public abstract class BeanUtil {

    /**
     * 复制一个对象的属性值到另一个对象
     *
     * @param source                复制源
     * @param target                目标
     * @param ignoreProperties     忽视的属性值
     * @return                      返回目标
     */
    public static Object copyProperties(Object source, Object target, String... ignoreProperties) {
        if (source == null) {
            return target;
        }
        BeanUtils.copyProperties(source, target, ignoreProperties);
        return target;
    }

    /**
     * 这段代码是一个泛型方法，用于复制一个列表，并将其转换为目标类型的列表。
     *
     * @param sources   源列表，即需要复制的原始列表。
     * @param clazz     目标类型的Class对象，表示希望将源列表中的元素转换为的目标类型。
     * @param <T>       该方法使用了泛型<T>来表示目标类型。通过在方法签名中定义泛型类型<T>，我们可以使该方法适用于不同类型的列表。
     * @return          方法返回一个与目标类型相同的列表。
     */
    public static <T> List<T> copyList(List sources, Class<T> clazz) {
        return copyList(sources, clazz, null);
    }

    /**
     * 复制一个列表，并将其转换为目标类型的列表
     *
     * @param sources   源列表，即需要复制的原始列表
     * @param clazz     目标类型
     * @param callback  回调函数
     * @param <T>       该方法使用了泛型<T>来表示目标类型。通过在方法签名中定义泛型类型<T>，我们可以使该方法适用于不同类型的列表。
     * @return          返回目标列表
     */
    public static <T> List<T> copyList(List sources, Class<T> clazz, Callback<T> callback) {
        List<T> targetList = new ArrayList<>();
        if (sources != null) {
            try {
                for (Object source : sources) {
                    T target = clazz.newInstance();
                    copyProperties(source, target);
                    if (callback != null) {
                        callback.set(source, target);
                    }
                    targetList.add(target);
                }
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return targetList;
    }

    /**
     * 将一个java对象转化为Map
     *
     * @param bean                  需要转化的对象
     * @param ignoreProperties     需要忽视的属性名
     * @return                       返回一个Map
     */
    public static Map<String, Object> toMap(Object bean, String... ignoreProperties) {
        Map<String, Object> map = new LinkedHashMap<>();
        // 将忽视的属性名转化为列表
        List<String> ignoreList = new ArrayList<>(Arrays.asList(ignoreProperties));
        // 在忽视列表中加入“class”
        ignoreList.add("class");
        // beanWrapper用于访问bean对象的属性
        BeanWrapper beanWrapper = PropertyAccessorFactory.forBeanPropertyAccess(bean);
        // 遍历bean对象的所有属性描述符PropertyDescriptor
        for (PropertyDescriptor pd : beanWrapper.getPropertyDescriptors()) {
            // 判断属性是否在忽略列表中，且该属性可读
            if (!ignoreList.contains(pd.getName()) && beanWrapper.isReadableProperty(pd.getName())) {
                // 则获取属性值，并将属性名和属性值放入Map中吗，key是属性名，值是属性值
                Object propertyValue = beanWrapper.getPropertyValue(pd.getName());
                map.put(pd.getName(), propertyValue);
            }
        }
        return map;
    }

    /**
     * 将一个Map对象转换为一个Java对象
     *
     * @param map       要转换的Map对象
     * @param beanType  要转换成的目标Java对象的类
     * @param <T>
     * @return
     */
    public static <T> T toBean(Map<String, Object> map, Class<T> beanType) {
        // BeanWrapperImpl对象，用于访问目标Java对象的属性
        BeanWrapper beanWrapper = new BeanWrapperImpl(beanType);
        // 遍历Map中的所有键值对
        map.forEach((key, value) -> {
            // 判断在目标Java对象中是否存在该属性，并且该属性可写
            if (beanWrapper.isWritableProperty(key)) {
                // 将键值对中的值设置为目标Java对象的属性值
                beanWrapper.setPropertyValue(key, value);
            }
        });
        // 将BeanWrapper对象内部封装的Java对象返回
        return (T) beanWrapper.getWrappedInstance();
    }

    public static interface Callback<T> {
        void set(Object source, T target);
    }

    //检查Pojo对象是否有null字段
    public static boolean checkPojoNullField(Object o, Class<?> clz) {
        try {
            Field[] fields = clz.getDeclaredFields();
            for (Field field : fields) {
                field.setAccessible(true);
                if (field.get(o) == null) {
                    return false;
                }
            }
            if (clz.getSuperclass() != Object.class) {
                return checkPojoNullField(o, clz.getSuperclass());
            }
            return true;
        } catch (IllegalAccessException e) {
            return false;
        }
    }
}
